 /*******************************************************************************
  * Copyright (c) 2006, 2007 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.core.internal.databinding;

 import java.util.ArrayList ;
 import java.util.HashMap ;
 import java.util.Iterator ;
 import java.util.List ;
 import java.util.Map ;
 import java.util.Set ;

 import org.eclipse.core.databinding.Binding;
 import org.eclipse.core.databinding.observable.ChangeEvent;
 import org.eclipse.core.databinding.observable.Diffs;
 import org.eclipse.core.databinding.observable.IChangeListener;
 import org.eclipse.core.databinding.observable.Realm;
 import org.eclipse.core.databinding.observable.list.WritableList;
 import org.eclipse.core.databinding.observable.map.IMapChangeListener;
 import org.eclipse.core.databinding.observable.map.MapDiff;
 import org.eclipse.core.databinding.observable.map.ObservableMap;
 import org.eclipse.core.databinding.observable.value.IObservableValue;
 import org.eclipse.core.runtime.IStatus;

 /**
  * @since 1.0
  *
  */
 public class ValidationStatusMap extends ObservableMap {

     private boolean isDirty = true;

     private final WritableList bindings;

     private List dependencies = new ArrayList ();

     private IChangeListener markDirtyChangeListener = new IChangeListener() {
         public void handleChange(ChangeEvent event) {
             markDirty();
         }
     };

     /**
      * @param realm
      * @param bindings
      */
     public ValidationStatusMap(Realm realm, WritableList bindings) {
         super(realm, new HashMap ());
         this.bindings = bindings;
         bindings.addChangeListener(markDirtyChangeListener);
     }

     protected void getterCalled() {
         recompute();
         super.getterCalled();
     }

     private void markDirty() {
         // since we are dirty, we don't need to listen anymore
 removeElementChangeListener();
         final Map oldMap = wrappedMap;
         // lazy computation of diff
 MapDiff mapDiff = new MapDiff() {
             private MapDiff cachedDiff = null;

             private void ensureCached() {
                 if (cachedDiff == null) {
                     recompute();
                     cachedDiff = Diffs.computeMapDiff(oldMap, wrappedMap);
                 }
             }

             public Set getAddedKeys() {
                 ensureCached();
                 return cachedDiff.getAddedKeys();
             }

             public Set getChangedKeys() {
                 ensureCached();
                 return cachedDiff.getChangedKeys();
             }

             public Object getNewValue(Object key) {
                 ensureCached();
                 return cachedDiff.getNewValue(key);
             }

             public Object getOldValue(Object key) {
                 ensureCached();
                 return cachedDiff.getOldValue(key);
             }

             public Set getRemovedKeys() {
                 ensureCached();
                 return cachedDiff.getRemovedKeys();
             }
         };
         wrappedMap = new HashMap ();
         isDirty = true;
         fireMapChange(mapDiff);
     }

     private void recompute() {
         if (isDirty) {
             Map newContents = new HashMap ();
             for (Iterator it = bindings.iterator(); it.hasNext();) {
                 Binding binding = (Binding) it.next();
                 IObservableValue validationError = binding
                         .getValidationStatus();
                 dependencies.add(validationError);
                 validationError.addChangeListener(markDirtyChangeListener);
                 IStatus validationStatusValue = (IStatus) validationError
                         .getValue();
                 newContents.put(binding, validationStatusValue);
             }
             wrappedMap.putAll(newContents);
             isDirty = false;
         }
     }

     /*
      * (non-Javadoc)
      *
      * @see org.eclipse.core.databinding.observable.list.ObservableList#dispose()
      */
     public void dispose() {
         bindings.removeChangeListener(markDirtyChangeListener);
         removeElementChangeListener();
         super.dispose();
     }

     private void removeElementChangeListener() {
         for (Iterator it = dependencies.iterator(); it.hasNext();) {
             IObservableValue observableValue = (IObservableValue) it.next();
             observableValue.removeChangeListener(markDirtyChangeListener);
         }
     }
     
     public synchronized void addChangeListener(IChangeListener listener) {
         // this ensures that the next change will be seen by the new listener.
 recompute();
         super.addChangeListener(listener);
     }
     
     public synchronized void addMapChangeListener(IMapChangeListener listener) {
         // this ensures that the next change will be seen by the new listener.
 recompute();
         super.addMapChangeListener(listener);
     }

 }

